/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Negocio.Administrador;

import Datos.Factura;
import Negocio.Cargador.Cargador;
import Negocio.Contenedor.ListaBailarinas;
import Negocio.Contenedor.ListaCuentas;
import Negocio.Contenedor.ListaMesas;
import Negocio.Contenedor.ListaOrdenes;
import Negocio.Contenedor.ListaProductos;
import Negocio.Contenedor.ListaSaloneros;
import java.awt.Component;
import java.sql.ResultSet;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Date;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.Group;
import javax.swing.GroupLayout.ParallelGroup;
import javax.swing.GroupLayout.SequentialGroup;
import javax.swing.JButton;
import javax.swing.JList;
import javax.swing.JPanel;

public class Administrador{

    private Cargador cargador = new Cargador();
    private ListaBailarinas listaBailarinas = new ListaBailarinas();
    private ListaProductos listaProductos = new ListaProductos();
    private ListaSaloneros listaSaloneros = new ListaSaloneros();
    private ListaMesas listaMesas = new ListaMesas();
    private ListaCuentas listaCuentas = new ListaCuentas();
    private ListaOrdenes listaOrdenes = new ListaOrdenes();

    public Administrador() {
    }

    public Cargador getCargador() {
        return cargador;
    }

    public void setCargador(Cargador cargador) {
        this.cargador = cargador;
    }

    public void conectar() {
        cargador.conectar();
    }

    //-----------------------------INICIO DE BAILARINAS-----------------------------//
    public boolean insertarBailarina(String nombreArtistico, int cedula, String nombreReal, int edad, int telefono, String direccion, JList lista, JList listaOrden) {
        boolean resultado = cargador.insertarBailarina(nombreArtistico, cedula, nombreReal, edad, telefono, direccion);
        if (resultado) {
            cargador.cargarArrayBailarinas(listaBailarinas);
            listaBailarinas.ordenarLista();
            cargador.actualizarLbBailarinas(lista, listaOrden, listaBailarinas);
        }
        return resultado;
    }

    public void cargarDatosBailarinas(JList lista, JList listaOrden) {
        cargador.cargarArrayBailarinas(listaBailarinas);
        cargador.actualizarLbBailarinas(lista, listaOrden, listaBailarinas);
    }

    public boolean eliminarBailarina(int idBailarina, JList lista, JList listaOrden) {
        boolean resultado = cargador.eliminarBailarina(idBailarina);
        if (resultado) {
            cargador.cargarArrayBailarinas(listaBailarinas);
            listaBailarinas.ordenarLista();
            cargador.actualizarLbBailarinas(lista, listaOrden, listaBailarinas);
        }
        return resultado;
    }

    public String[] bailarinaSeleccionada(int idBailarina) {
        return cargador.informacionBailarina(idBailarina);
    }

    public boolean modificarBailarina(int idBailarina, String nombreArtistico, int cedula, String nombreReal, int edad, int telefono, String direccion, JList lista, JList listaOrden) {
        boolean resultado = cargador.modificarBailarina(idBailarina, nombreArtistico, cedula, nombreReal, edad, telefono, direccion);
        if (resultado) {
            cargador.cargarArrayBailarinas(listaBailarinas);
            listaBailarinas.ordenarLista();
            cargador.actualizarLbBailarinas(lista, listaOrden, listaBailarinas);
        }
        return resultado;
    }

    //-----------------------------FINAL DE BAILARINAS-----------------------------//
    //-----------------------------INICIO DE SALONEROS-----------------------------//
    public boolean insertarSalonero(String nombre, int cedula, int edad, int telefono, String direccion, JList lista, JList listaOrden) {
        boolean resultado = cargador.insertarSalonero(nombre, cedula, edad, telefono, direccion);
        if (resultado) {
            cargador.cargarArraySaloneros(listaSaloneros);
            listaSaloneros.ordenarLista();
            cargador.actualizarLbSaloneros(lista, listaOrden, listaSaloneros);
        }
        return resultado;
    }

    public void cargarDatosSaloneros(JList lista, JList listaOrden) {
        cargador.cargarArraySaloneros(listaSaloneros);
        cargador.actualizarLbSaloneros(lista, listaOrden, listaSaloneros);
    }

    public boolean eliminarSalonero(int idSalonero, JList lista, JList listaOrden) {
        boolean resultado = cargador.eliminarSalonero(idSalonero);
        if (resultado) {
            cargador.cargarArraySaloneros(listaSaloneros);
            listaSaloneros.ordenarLista();
            cargador.actualizarLbSaloneros(lista, listaOrden, listaSaloneros);
        }
        return resultado;
    }

    public String[] saloneroSeleccionado(int idSalonero) {
        return cargador.informacionSalonero(idSalonero);
    }

    public boolean modificarSalonero(int idSalonero, String nombre, int cedula, int edad, int telefono, String direccion, JList lista, JList listaOrden) {
        boolean resultado = cargador.modificarSalonero(idSalonero, nombre, cedula, edad, telefono, direccion);
        if (resultado) {
            cargador.cargarArraySaloneros(listaSaloneros);
            listaSaloneros.ordenarLista();
            cargador.actualizarLbSaloneros(lista, listaOrden, listaSaloneros);
        }
        return resultado;
    }

    //-----------------------------FINAL DE SALONEROS-----------------------------//
    
    //-----------------------------INICIO DE PRODUCTOS-----------------------------//
    public boolean insertarProducto(String nombre, double costo, double comisionBailarina, JList lista) {
        boolean resultado = cargador.insertarProducto(nombre, costo, comisionBailarina);
        if (resultado) {
            cargador.cargarArrayProductos(listaProductos);
            listaProductos.ordenarLista();
            cargador.actualizarLbProductos(lista, listaProductos);
        }
        return resultado;
    }

    public int cargarDatosProductos(JList lista) {
        cargador.cargarArrayProductos(listaProductos);
        cargador.actualizarLbProductos(lista, listaProductos);
        return listaProductos.size();
    }

    public boolean eliminarProducto(int codigo, JList lista) {
        boolean resultado = cargador.eliminarProducto(codigo);
        if (resultado) {
            cargador.cargarArrayProductos(listaProductos);
            listaProductos.ordenarLista();
            cargador.actualizarLbProductos(lista, listaProductos);
        }
        return resultado;
    }

    public String[] productoSeleccionado(int idProducto) {
        return cargador.informacionProducto(idProducto);
    }

    public boolean modificarProducto(int codigo, String nombre, double costo, double comisionBailarina, JList lista) {
        boolean resultado = cargador.modificarProducto(codigo, nombre, costo, comisionBailarina);
        if (resultado) {
            cargador.cargarArrayProductos(listaProductos);
            listaProductos.ordenarLista();
            cargador.actualizarLbProductos(lista, listaProductos);
        }
        return resultado;
    }

    public int sizeProductos() {
        return listaProductos.size();
    }

    public Component getBtnElementoProducto(int i) {
        return listaProductos.getBtnElemento(i);
    }

    public void asignarBotonesProductos(JButton[] botones) {
        listaProductos.asignarBotones(botones);
    }

    public Group parallelGroupHorizontalProductos(GroupLayout pnlProductosLayout) {
        ParallelGroup parallelGroup = pnlProductosLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING);
        SequentialGroup sequentialGroup = pnlProductosLayout.createSequentialGroup();
        int contProductos = 0;
        for (int i = 0; i < listaProductos.size(); i++) {
            if (contProductos == 4) {
                parallelGroup.addGroup(sequentialGroup);
                sequentialGroup = pnlProductosLayout.createSequentialGroup();
                contProductos = 0;
                sequentialGroup.addComponent(listaProductos.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 81, javax.swing.GroupLayout.PREFERRED_SIZE);
                if ((i + 1) == listaProductos.size()) {
                    parallelGroup.addGroup(sequentialGroup);
                } else {
                    sequentialGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED);
                }
                contProductos++;
            } else {
                sequentialGroup.addComponent(listaProductos.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 81, javax.swing.GroupLayout.PREFERRED_SIZE);
                if ((contProductos < 4) && ((i + 1) < listaProductos.size())) {
                    sequentialGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED);
                }
                if ((i + 1) == listaProductos.size()) {
                    parallelGroup.addGroup(sequentialGroup);
                }
                contProductos++;
            }
        }
        return parallelGroup;
    }

    public Group parallelGroupVerticalProductos(GroupLayout pnlProductosLayout, SequentialGroup seqGroup) {
        ParallelGroup parallelGroup = pnlProductosLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE);

        int contProductos = 0;
        for (int i = 0; i < listaProductos.size(); i++) {
            if (contProductos == 4) {
                seqGroup.addGroup(parallelGroup);
                seqGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED);
                parallelGroup = pnlProductosLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE);
                parallelGroup.addComponent(listaProductos.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 77, javax.swing.GroupLayout.PREFERRED_SIZE);
                contProductos = 1;
                if ((i + 1) == listaProductos.size()) {
                    seqGroup.addGroup(parallelGroup);
                }
            } else {
                contProductos++;
                if (((i + 1) == listaProductos.size()) && ((((i / 4) * 4) + 1) == listaProductos.size())) { //((i + 1) == listaMesas.size()) && (contMesas == 6)
                    seqGroup.addGroup(parallelGroup);
                    seqGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED);
                    parallelGroup = pnlProductosLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE);
                    parallelGroup.addComponent(listaProductos.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 77, javax.swing.GroupLayout.PREFERRED_SIZE);
                    seqGroup.addGroup(parallelGroup);
                } else {
                    parallelGroup.addComponent(listaProductos.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 77, javax.swing.GroupLayout.PREFERRED_SIZE);
                    if ((i + 1) == listaProductos.size()) {
                        seqGroup.addGroup(parallelGroup);
                    }
                }
            }
        }
        return seqGroup;
    }

    //-----------------------------FINAL DE PRODUCTOS-----------------------------//
    
    //-----------------------------INICIO DE MESAS-----------------------------//
    public boolean insertarMesa(int numMesa, int capacidad, javax.swing.JButton botonMesa) {
        boolean resultado = cargador.insertarMesa(numMesa, capacidad);
        if (resultado) {
            cargador.cargarArrayMesas(listaMesas);
            listaMesas.ordenarLista();
        }
        return resultado;
    }

    public Group parallelGroupHorizontal(GroupLayout pnlMesasLayout) {
        ParallelGroup parallelGroup = pnlMesasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING);
        SequentialGroup sequentialGroup = pnlMesasLayout.createSequentialGroup();
        int contMesas = 0;
        for (int i = 0; i < listaMesas.size(); i++) {
            if (contMesas == 6) {
                parallelGroup.addGroup(sequentialGroup);
                sequentialGroup = pnlMesasLayout.createSequentialGroup();
                contMesas = 0;
                sequentialGroup.addComponent(listaMesas.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 103, javax.swing.GroupLayout.PREFERRED_SIZE);
                if ((i + 1) == listaMesas.size()) {
                    parallelGroup.addGroup(sequentialGroup);
                } else {
                    sequentialGroup.addGap(18, 18, 18);
                }
                    contMesas++;
            } else {
                sequentialGroup.addComponent(listaMesas.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 103, javax.swing.GroupLayout.PREFERRED_SIZE);
                if ((contMesas < 5) && ((i + 1) < listaMesas.size())) {
                    sequentialGroup.addGap(18, 18, 18);
                }
                if ((i + 1) == listaMesas.size()) {
                    parallelGroup.addGroup(sequentialGroup);
                }
                    contMesas++;
            }
        }
        return parallelGroup;
    }

    public Group parallelGroupVertical(GroupLayout pnlMesasLayout, SequentialGroup seqGroup) {
        ParallelGroup parallelGroup = pnlMesasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE);

        int contMesas = 0;
        for (int i = 0; i < listaMesas.size(); i++) {
            if (contMesas == 6) {
                seqGroup.addGroup(parallelGroup);
                seqGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED);
                parallelGroup = pnlMesasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE);
                parallelGroup.addComponent(listaMesas.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 81, javax.swing.GroupLayout.PREFERRED_SIZE);
                contMesas = 1;
                if ((i + 1) == listaMesas.size()) {
                    seqGroup.addGroup(parallelGroup);
                }
            } else {
                    contMesas++;
                if (((i + 1) == listaMesas.size()) && ((((i / 6) * 6) + 1) == listaMesas.size())) { //((i + 1) == listaMesas.size()) && (contMesas == 6)
                    seqGroup.addGroup(parallelGroup);
                    seqGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED);
                    parallelGroup = pnlMesasLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE);
                    parallelGroup.addComponent(listaMesas.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 81, javax.swing.GroupLayout.PREFERRED_SIZE);
                    seqGroup.addGroup(parallelGroup);
                } else {
                    parallelGroup.addComponent(listaMesas.getBtnElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 81, javax.swing.GroupLayout.PREFERRED_SIZE);
                    if ((i + 1) == listaMesas.size()) {
                        seqGroup.addGroup(parallelGroup);
                    }
                }
            }
        }
        return seqGroup;
    }

    public int cargarMesas() {
        cargador.cargarArrayMesas(listaMesas);
        return listaMesas.size();
    }

    public int sizeMesas() {
        return listaMesas.size();
    }

    public Component getBtnElemento(int i) {
        return listaMesas.getBtnElemento(i);
    }

    public void asignarBotones(JButton[] botones) {
        listaMesas.ordenarLista();
        listaMesas.asignarBotones(botones);
    }

    public boolean eliminarMesa(int numMesa) {
        return cargador.eliminarMesa(listaMesas.getCodigoMesaActiva(numMesa));
    }
    
    public void eliminarCuentasActivasMesa(int idMesa) {
        try{
            cargador.eliminarCuentasActivasMesa(listaMesas.getCodigoMesaActiva(idMesa));
        }catch(Exception e){
        }
    }

    //-----------------------------FINAL DE MESAS-----------------------------//

    //-----------------------------INICIO DE CUENTAS-----------------------------//


    public void guardarDescuento(int idCuenta, double descuento) {
        cargador.guardarDescuento(idCuenta,descuento);
    }

    public void cargarDatosCuenta(JList lsCuentasActivas, int idMesa) {
        cargador.cargarArrayCuentas(listaCuentas);
        cargador.actualizarLbCuentas(lsCuentasActivas, listaCuentas, idMesa);
    }

    public boolean insertarCuenta(int mesa, String nombreCliente, int numeroPersonas, JList lsCuentasActivas) {
        boolean resultado = cargador.agregarCuenta(listaMesas.getCodigoMesaActiva(mesa), mesa, nombreCliente, numeroPersonas);
        if (resultado) {
            cargador.cargarArrayCuentas(listaCuentas);
            listaCuentas.ordenarLista();
            cargador.actualizarLbCuentas(lsCuentasActivas, listaCuentas, mesa);
        }
        return resultado;
    }

    public boolean eliminarCuenta(int idCuenta, JList lsCuentasActivas, int mesa) {
        boolean resultado = cargador.eliminarCuenta(idCuenta);
        if (resultado) {
            cargador.cargarArrayCuentas(listaCuentas);
            listaCuentas.ordenarLista();
            cargador.actualizarLbCuentas(lsCuentasActivas, listaCuentas, mesa);
        }
        return resultado;
    }

    public boolean modificarCuenta(int idCuenta, int mesa, String nombreCliente, int numeroPersonas, JList lsCuentasActivas) {
        boolean resultado = cargador.modificarCuenta(idCuenta, listaMesas.getCodigoMesaActiva(mesa), mesa, nombreCliente, numeroPersonas);
        if (resultado) {
            cargador.cargarArrayCuentas(listaCuentas);
            listaCuentas.ordenarLista();
            cargador.actualizarLbCuentas(lsCuentasActivas, listaCuentas, mesa);
        }
        return resultado;
    }

    public String[] cuentaSeleccionada(int idCuenta) {
        return cargador.informacionCuenta(idCuenta);
    }

    //-----------------------------FINAL DE CUENTAS-----------------------------//

    //-----------------------------INICIO DE ORDENES-----------------------------//

    public boolean agregarOrden(int nCuenta, int nMesa, int nProducto, int nTipo, int nSalonero, int nBailarina, int activa) {
        boolean resultado = cargador.agregarOrden(nCuenta, listaMesas.getCodigoMesaActiva(nMesa), nMesa, nProducto, nTipo, nSalonero, nBailarina, activa);
        if (resultado) {
            cargador.cargarArrayOrdenes(listaOrdenes, nCuenta);
            listaOrdenes.ordenarLista();
        }
        return resultado;
    }


    public int cargarOrdenes(int idCuenta) {
        cargador.cargarArrayOrdenes(listaOrdenes, idCuenta);
        return listaOrdenes.size();
    }

    public void asignarPanelesOrdenes(JPanel[] paneles) {
        listaOrdenes.asignarPaneles(paneles);
    }

    public Group parallelGroupHorizontalOrdenes(GroupLayout pnlOrdenesLayout) {
        ParallelGroup parallelGroup = pnlOrdenesLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING, false);
        String ordenesRepetidas[] = new String[listaOrdenes.size()];
        for (int i = 0; i < ordenesRepetidas.length; i++) {
            ordenesRepetidas[i] = "";
        }
        for (int i = 0; i < listaOrdenes.size(); i++) {
            if (chequeaOrdenNoRepetida(ordenesRepetidas, ""+listaOrdenes.getCodigoProducto(i)+listaOrdenes.getTipo(i))) {
                parallelGroup.addComponent(listaOrdenes.getPanelElemento(i), javax.swing.GroupLayout.DEFAULT_SIZE, 320, Short.MAX_VALUE);
                ordenesRepetidas[i] = ""+listaOrdenes.getCodigoProducto(i)+listaOrdenes.getTipo(i);
            }
        }
        return parallelGroup;
    }

    public Group parallelGroupVerticalOrdenes(GroupLayout pnlOrdenesLayout) {
        SequentialGroup sequentialGroup = pnlOrdenesLayout.createSequentialGroup();
        String ordenesRepetidas[] = new String[listaOrdenes.size()];
        for (int i = 0; i < ordenesRepetidas.length; i++) {
            ordenesRepetidas[i] = "";
        }
        for (int i = 0; i < listaOrdenes.size(); i++) {
            if (chequeaOrdenNoRepetida(ordenesRepetidas, ""+listaOrdenes.getCodigoProducto(i)+listaOrdenes.getTipo(i))) {
                sequentialGroup.addComponent(listaOrdenes.getPanelElemento(i), javax.swing.GroupLayout.PREFERRED_SIZE, 40, javax.swing.GroupLayout.PREFERRED_SIZE);
                if ((i + 1) < listaOrdenes.size()) {
                    sequentialGroup.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED);
                } else {
                    sequentialGroup.addContainerGap(100, Short.MAX_VALUE);
                }
                ordenesRepetidas[i] = ""+listaOrdenes.getCodigoProducto(i)+listaOrdenes.getTipo(i);
            }
        }
        return sequentialGroup;
    }

    public boolean mesaExiste(int numMesa) {
        return listaMesas.numMesaOcupado(numMesa);
    }

    public String[] informacionProductoDeOrden(int i) {
        return productoSeleccionado(listaOrdenes.getInfoProducto(i));
    }

    public int cantidadProductoEnCuenta(String cantidad, int tipoOrden) {
        return listaOrdenes.cantidadProductoEnCuenta(Integer.parseInt(cantidad), tipoOrden);
    }

    private boolean chequeaOrdenNoRepetida(String[] ordenesRepetidas, String productoTipoOrden) {
        for (int i = 0; i < ordenesRepetidas.length; i++) {
            if(ordenesRepetidas[i].equals(productoTipoOrden))
                return false;
        }
        return true;
    }

    public double sumarOrdenes() {
        double subtotal = 0;
        for (int i = 0; i < listaOrdenes.size(); i++) {
             String infoProducto [] = productoSeleccionado(listaOrdenes.getInfoProducto(i));
             switch(listaOrdenes.tipoOrden(i)){
                 case 1: subtotal += Double.parseDouble(infoProducto[2]);
                         break;
                 case 2: break;
                 case 3: subtotal += Double.parseDouble(infoProducto[2]) + Double.parseDouble(infoProducto[3]);
                         break;
             }
        }
        return subtotal;
    }

    public int getTipoOrden(int i) {
        return listaOrdenes.getTipo(i);
    }

    public boolean transferirCuenta(int numMesaNueva, int idCuenta) {
        return cargador.transferirCuenta(listaMesas.getCodigoMesaActiva(numMesaNueva),numMesaNueva, idCuenta);
    }

    public boolean eliminarOrden(int idProducto, int tipo) {
        int idOrden = listaOrdenes.getOrdenProductoTipo(idProducto, tipo);
        if (idOrden > 0) {
            if (cargador.eliminarOrden(idOrden)) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    public int facturar(int nCuentaFacturar, String fechaCierre) {
        if (listaOrdenes.size() > 0) {
            if (cargador.facturar(nCuentaFacturar, fechaCierre)) {
                return 1; // Se facturo.
            }else
                return 3; // No se facturo
        }else
            return 2; // No hay ordenes para esa cuenta
    }

    public String[] textoProductosCierre(String fechaCierre) {
        cargador.cargarOrdenesDia(listaOrdenes, fechaCierre);
        int cantidadOrden = 0;
        ArrayList<String> listaOrdenesNoRep = new ArrayList<String>();
        int numProducto = 0;
        String productoRepetido[] = new String[listaOrdenes.size()];
        for (int i = 0; i < productoRepetido.length; i++) {
             productoRepetido[i] = "";
        }
        for (int a = 0; a < listaOrdenes.size(); a++) {
            numProducto = listaOrdenes.getCodigoProducto(a);
            if (chequeaOrdenNoRepetida(productoRepetido, ""+numProducto)) {
                cantidadOrden = cantidadProductoEnCuenta(numProducto+"", listaOrdenes.getTipo(a));
                String infoP [] = cargador.informacionProducto(listaOrdenes.getCodigoProducto(a));
                double precio = 0;
                DecimalFormat df = new DecimalFormat("0.00");
                switch(listaOrdenes.getTipo(a)){
                    case 1: precio = (((Double.parseDouble(infoP[2]) * cantidadOrden)/123)*100);
                            break;
                    case 2: infoP[2] += "(Cor)";
                            break;
                    case 3: precio = (Double.parseDouble(infoP[2]) + Double.parseDouble(infoP[3])) * cantidadOrden;
                            break;
                }
                listaOrdenesNoRep.add(cantidadOrden+"   "+infoP[1]+"            "+df.format(precio));
                productoRepetido[a] = numProducto+"";
                cantidadOrden = 0;
            }
        }
        String resultado [] = new String [listaOrdenesNoRep.size()];
        for (int i = 0; i < resultado.length; i++) {
            resultado[i] = listaOrdenesNoRep.get(i);
            System.out.println(resultado[i]);
        }
        return resultado;
    }

    public String[] textoAbajoCierre() {
        cargador.cargarArrayProductos(listaProductos);
        double subtotal = 0;
        double totalVentas = 0;
        double totalIV = 0;
        double totalServ = 0;
        double descuento = 0;
        int ultimaCuenta = 0;
        int cuentaNueva = 0;

        for(int i = 0; i<listaOrdenes.size(); i++)
        {
            cuentaNueva = listaOrdenes.getListaOrdenes().get(i).getnCuenta();
            if(listaOrdenes.getTipo(i)!=2)
            {
                if(cuentaNueva!=ultimaCuenta)
                {
                    descuento += cargador.cargarDescuento(cuentaNueva);
                    ultimaCuenta = cuentaNueva;
                }
                double subtProducto = (((listaProductos.getPrecio(listaOrdenes.getInfoProducto(i)))/123)*100);
                subtotal += subtProducto;
                totalIV += subtProducto*0.13;
                totalServ += subtProducto*0.1;
            }
        }
        totalVentas = (subtotal + totalIV + totalServ)-descuento;
        String [] textoAbajo = new String [7];
        DecimalFormat df = new DecimalFormat("0.00");
        textoAbajo [0] = "";//ESPACIO PARA SEPARARLO DE LOS PRODUCTOS
        textoAbajo [1] = "Subtotal = "+df.format(subtotal);
        textoAbajo [2] = "-----------------------------------------";
        textoAbajo [2] = "Total I.V. = "+df.format(totalIV);
        textoAbajo [3] = "Total Servicio = "+df.format(totalServ);
        textoAbajo [4] = "Descuento = "+df.format(descuento);
        textoAbajo [5] = "-----------------------------------------";
        textoAbajo [6] = "Total Ventas = "+df.format(totalVentas);

        return textoAbajo;
    }

    public String [] textoOrdenes() {
        int cantidadOrden = 0;
        ArrayList<String> listaOrdenesNoRep = new ArrayList<String>();
        int numProducto = 0;
        String productoRepetido[] = new String[listaOrdenes.size()];
        for (int i = 0; i < productoRepetido.length; i++) {
             productoRepetido[i] = "";
        }
        for (int a = 0; a < listaOrdenes.size(); a++) {
            numProducto = listaOrdenes.getCodigoProducto(a);
            if (chequeaOrdenNoRepetida(productoRepetido, ""+numProducto)) {
                cantidadOrden = cantidadProductoEnCuenta(numProducto+"", listaOrdenes.getTipo(a));
                String infoP [] = cargador.informacionProducto(listaOrdenes.getCodigoProducto(a));
                double precio = 0;
                DecimalFormat df = new DecimalFormat("0.00");
                switch(listaOrdenes.getTipo(a)){
                    case 1: precio = (((Double.parseDouble(infoP[2]) * cantidadOrden)/123)*100);
                            break;
                    case 2: infoP[2] += "(Cor)";
                            break;
                    case 3: precio = (Double.parseDouble(infoP[2]) + Double.parseDouble(infoP[3])) * cantidadOrden;
                            break;
                }
                listaOrdenesNoRep.add(cantidadOrden+"   "+infoP[1]+"            "+df.format(precio));
                productoRepetido[a] = numProducto+"";
                cantidadOrden = 0;
            }
        }
        String resultado [] = new String [listaOrdenesNoRep.size()];
        for (int i = 0; i < resultado.length; i++) {
            resultado[i] = listaOrdenesNoRep.get(i);
            System.out.println(resultado[i]);
        }
        return resultado;
    }

    public void imprimirFactura(String[] textoArriba, String[] textoOrdenes, String[] textoAbajo) {
        try
        {
            Factura f = new Factura (textoArriba,textoAbajo,textoOrdenes,"Arial",6);
            f.imprimirFactura();
        }
        catch(Exception e)
        {}
    }




    //-----------------------------FINAL DE ORDENES-----------------------------//

    //-----------------------------INICIO DE REPORTES-----------------------------//
    public ResultSet getReport(String idReporte, Date desde, Date hasta){
        ResultSet resultado = null;
        try{
            System.out.println("El ID del reporte es: "+idReporte+"\n");
        switch(Integer.parseInt(idReporte)){
            case 0:
                System.out.println("Switch ingresa al paso 0"+"\n");
                resultado = cargador.getReportFichas();
        break;
            case 1:
                System.out.println("Switch ingresa al paso 1"+"\n");
                resultado = cargador.getReportComision();
        break;
            case 2:
                System.out.println("Switch ingresa al paso 2"+"\n");
                resultado = cargador.getReportVentas();
        break;
        }
        }catch(Exception ex)
        {
            System.out.println(ex.getMessage()+"\n");
        }
        return resultado;
    }
     //-----------------------------FIN DE REPORTES-----------------------------//
}
